home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / sunclock / sunclock.c < prev    next >
C/C++ Source or Header  |  1995-05-25  |  21KB  |  913 lines
  1. /*
  2.  * Sun clock.  X11 version by John Mackin.
  3.  *
  4.  * This program was derived from, and is still in part identical with, the
  5.  * Suntools Sun clock program whose author's comment appears immediately
  6.  * below.  Please preserve both notices.
  7.  *
  8.  * The X11R3/4 version of this program was written by John Mackin, at the
  9.  * Basser Department of Computer Science, University of Sydney, Sydney,
  10.  * New South Wales, Australia; <john@cs.su.oz.AU>.  This program, like
  11.  * the one it was derived from, is in the public domain: `Love is the
  12.  * law, love under will.'
  13.  */
  14.  
  15. /*
  16.  
  17.     Sun clock
  18.  
  19.     Designed and implemented by John Walker in November of 1988.
  20.  
  21.     Version for the Sun Workstation.
  22.  
  23.     The algorithm used to calculate the position of the Sun is given in
  24.     Chapter 18 of:
  25.  
  26.     "Astronomical  Formulae for Calculators" by Jean Meeus, Third Edition,
  27.     Richmond: Willmann-Bell, 1985.  This book can be obtained from:
  28.  
  29.        Willmann-Bell
  30.        P.O. Box 35025
  31.        Richmond, VA  23235
  32.        USA
  33.        Phone: (804) 320-7016
  34.  
  35.     This program was written by:
  36.  
  37.        John Walker
  38.        Autodesk, Inc.
  39.        2320 Marinship Way
  40.        Sausalito, CA  94965
  41.        USA
  42.        Fax:   (415) 389-9418
  43.        Voice: (415) 332-2344 Ext. 2829
  44.        Usenet: {sun,well,uunet}!acad!kelvin
  45.        or: kelvin@acad.uu.net
  46.  
  47.     This  program is in the public domain: "Do what thou wilt shall be the
  48.     whole of the law".  I'd appreciate  receiving  any  bug  fixes  and/or
  49.     enhancements,  which  I'll  incorporate  in  future  versions  of  the
  50.     program.  Please leave the original attribution information intact    so
  51.     that credit and blame may be properly apportioned.
  52.  
  53.     Revision history:
  54.  
  55.     1.0  12/21/89  Initial version.
  56.           8/24/89  Finally got around to submitting.
  57.  
  58. */
  59.  
  60. #define    FAILFONT    "fixed"
  61.  
  62. #define    VERSION        "1.0"
  63.  
  64. #include "sunclock.h"
  65.  
  66. struct sunclock {
  67.     int        s_width;    /* size of pixmap */
  68.     int        s_height;
  69.     Window        s_window;    /* associated window */
  70.     Pixmap        s_pixmap;    /* and pixmap */
  71.     int        s_flags;    /* see below */
  72.     int        s_noon;        /* position of noon */
  73.     short *        s_wtab1;    /* current width table (?) */
  74.     short *        s_wtab;        /* previous width table (?) */
  75.     long        s_increm;    /* increment for fake time */
  76.     long        s_time;        /* time - real or fake, see flags */
  77.     GC        s_gc;        /* GC for writing text into window */
  78.     char *        (*s_tfunc)();    /* function to return the text */
  79.     char        s_text[80];    /* and the current text that's there */
  80.     int        s_textx;    /* where to draw the text */
  81.     int        s_texty;    /* where to draw the text */
  82.     long        s_projtime;    /* last time we projected illumination */
  83.     int        s_timeout;    /* time until next image update */
  84.     struct sunclock * s_next;    /* pointer to next clock context */
  85. };
  86.  
  87. /*
  88.  * bits in s_flags
  89.  */
  90.  
  91. #define    S_FAKE        01        /* date is fake, don't use actual time */
  92. #define    S_ANIMATE    02        /* do animation based on increment */
  93. #define    S_DIRTY        04        /* pixmap -> window copy required */
  94. #define    S_ICON        010        /* this is the icon window */
  95.  
  96. char *                strrchr();
  97. long                time();
  98.  
  99. double                jtime();
  100. double                gmst();
  101. char *                salloc();
  102. char *                bigtprint();
  103. char *                smalltprint();
  104. struct sunclock *        makeClockContext();
  105. Bool                evpred();
  106.  
  107. char *                Wdayname[] = {
  108.         "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
  109. };
  110. char *                Monname[] = {
  111.     "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
  112.     "Aug", "Sep", "Oct", "Nov", "Dec"
  113. };
  114.  
  115. struct geom {
  116.     int            mask;
  117.     int            x;
  118.     int            y;
  119. };
  120.  
  121. char *                Name;
  122. char *                Display_name = "";
  123. Display *            dpy;
  124. int                scr;
  125. unsigned long            Black;
  126. unsigned long            White;
  127. GC                GC_store;
  128. GC                GC_invert;
  129. GC                GC_bigf;
  130. GC                GC_smallf;
  131. XFontStruct *            SmallFont;
  132. XFontStruct *            BigFont;
  133. Pixmap                Mappix;
  134. Pixmap                Iconpix;
  135. Window                Icon;
  136. Window                Clock;
  137. struct sunclock *        Current;
  138. int                Iconic = 0;
  139. struct geom            Geom = { 0, 0, 0 };
  140. struct geom            Icongeom = { 0, 0, 0 };
  141.  
  142. main(argc, argv)
  143. int                argc;
  144. register char **        argv;
  145. {
  146.     char *            p;
  147.  
  148.     Name = *argv;
  149.     if (p = strrchr(Name, '/'))
  150.         Name = ++p;
  151.     parseArgs(argc, argv);
  152.  
  153.     dpy = XOpenDisplay(Display_name);
  154.     if (dpy == (Display *)NULL) {
  155.         fprintf(stderr, "%s: can't open display `%s'\n", Display_name);
  156.         exit(1);
  157.     }
  158.     scr = DefaultScreen(dpy);
  159.  
  160.     getColors();
  161.     getFonts();
  162.     makePixmaps();
  163.     makeWindows();
  164.     makeGCs(Clock, Mappix);
  165.     setAllHints(argc, argv);
  166.     makeClockContexts();
  167.  
  168.     XSelectInput(dpy, Clock, ExposureMask);
  169.     XSelectInput(dpy, Icon, ExposureMask);
  170.     XMapWindow(dpy, Clock);
  171.  
  172.     eventLoop();
  173.  
  174.     /*
  175.      * eventLoop() never returns, but one day it might, if someone adds a
  176.      * menu for animation or such with a "quit" option.
  177.      */
  178.  
  179.     shutDown();
  180.     exit(0);
  181. }
  182.  
  183. parseArgs(argc, argv)
  184. register int            argc;
  185. register char **        argv;
  186. {
  187.     while (--argc > 0) {
  188.         ++argv;
  189.         if (strcmp(*argv, "-display") == 0) {
  190.             needMore(argc, argv);
  191.             Display_name = *++argv;
  192.             --argc;
  193.         }
  194.         else if (strcmp(*argv, "-iconic") == 0)
  195.             Iconic++;
  196.         else if (strcmp(*argv, "-geometry") == 0) {
  197.             needMore(argc, argv);
  198.             getGeom(*++argv, &Geom);
  199.             --argc;
  200.         }
  201.         else if (strcmp(*argv, "-icongeometry") == 0) {
  202.             needMore(argc, argv);
  203.             getGeom(*++argv, &Icongeom);
  204.             --argc;
  205.         }
  206.         else if (strcmp(*argv, "-version") == 0) {
  207.             fprintf(stderr, "%s: version %s patchlevel %d\n",
  208.                 Name, VERSION, PATCHLEVEL);
  209.             exit(0);
  210.         }
  211.         else
  212.             usage();
  213.     }
  214. }
  215.  
  216. needMore(argc, argv)
  217. register int            argc;
  218. register char **        argv;
  219. {
  220.     if (argc == 1) {
  221.         fprintf(stderr, "%s: option `%s' requires an argument\n",
  222.             Name, *argv);
  223.         usage();
  224.     }
  225. }
  226.  
  227. getGeom(s, g)
  228. register char *            s;
  229. register struct geom *        g;
  230. {
  231.     register int        mask;
  232.     unsigned int        width;
  233.     unsigned int        height;
  234.  
  235.     mask = XParseGeometry(s, &g->x, &g->y, &width, &height);
  236.     if (mask == 0) {
  237.         fprintf(stderr, "%s: `%s' is a bad geometry specification\n",
  238.             Name, s);
  239.         exit(1);
  240.     }
  241.     if ((mask & WidthValue) || (mask & HeightValue))
  242.         fprintf(stderr, "%s: warning: width/height in geometry `%s' ignored\n",
  243.             Name, s);
  244.     g->mask = mask;
  245. }
  246.  
  247. /*
  248.  * Free resources.
  249.  */
  250.  
  251. shutDown()
  252. {
  253.     XFreeGC(dpy, GC_store);
  254.     XFreeGC(dpy, GC_invert);
  255.     XFreeGC(dpy, GC_bigf);
  256.     XFreeGC(dpy, GC_smallf);
  257.     XFreeFont(dpy, BigFont);
  258.     XFreeFont(dpy, SmallFont);
  259.     XFreePixmap(dpy, Mappix);
  260.     XFreePixmap(dpy, Iconpix);
  261.     XDestroyWindow(dpy, Clock);
  262.     XDestroyWindow(dpy, Icon);
  263.     XCloseDisplay(dpy);
  264. }
  265.  
  266. usage()
  267. {
  268.     fprintf(stderr,
  269.         "usage: %s [-display dispname] [-geometry +x+y] [-icongeometry +x+y] [-iconic] [-version]\n",
  270.         Name);
  271.     exit(1);
  272. }
  273.  
  274. /*
  275.  * Set up stuff the window manager will want to know.  Must be done
  276.  * before mapping window, but after creating it.
  277.  */
  278.  
  279. setAllHints(argc, argv)
  280. int                argc;
  281. char **                argv;
  282. {
  283.     XClassHint        xch;
  284.     XSizeHints        xsh;
  285.     XWMHints        xwmh;
  286.  
  287.     xch.res_name = Name;
  288.     xch.res_class = "Sunclock";
  289.     XSetClassHint(dpy, Clock, &xch);
  290.     XStoreName(dpy, Clock, Name);
  291.  
  292.     XSetCommand(dpy, Clock, argv, argc);
  293.  
  294.     XSetIconName(dpy, Clock, Name);
  295.  
  296.     xsh.flags = PSize | PMinSize | PMaxSize;
  297.     if (Geom.mask & (XValue | YValue)) {
  298.         xsh.x = Geom.x;
  299.         xsh.y = Geom.y;
  300.         xsh.flags |= USPosition;
  301.     }
  302.     xsh.width = xsh.min_width = xsh.max_width = large_map_width;
  303.     xsh.height = xsh.min_height = xsh.max_height = large_map_height;
  304.     XSetNormalHints(dpy, Clock, &xsh);
  305.  
  306.     xwmh.flags = InputHint | StateHint | IconWindowHint;
  307.     if (Icongeom.mask & (XValue | YValue)) {
  308.         xwmh.icon_x = Icongeom.x;
  309.         xwmh.icon_y = Icongeom.y;
  310.         xwmh.flags |= IconPositionHint;
  311.     }
  312.     xwmh.input = False;
  313.     xwmh.initial_state = Iconic ? IconicState : NormalState;
  314.     xwmh.icon_window = Icon;
  315.     XSetWMHints(dpy, Clock, &xwmh);
  316. }
  317.  
  318. makeWindows()
  319. {
  320.     register int        ht;
  321.     XSetWindowAttributes    xswa;
  322.     register int        mask;
  323.  
  324.     ht = icon_map_height + SmallFont->max_bounds.ascent +
  325.          SmallFont->max_bounds.descent + 2;
  326.     xswa.background_pixel = White;
  327.     xswa.border_pixel = Black;
  328.     xswa.backing_store = WhenMapped;
  329.     mask = CWBackPixel | CWBorderPixel | CWBackingStore;
  330.  
  331.     fixGeometry(&Geom, large_map_width, large_map_height);
  332.     Clock = XCreateWindow(dpy, RootWindow(dpy, scr), Geom.x, Geom.y,
  333.                   large_map_width, large_map_height, 3, CopyFromParent,
  334.                   InputOutput, CopyFromParent, mask, &xswa);
  335.  
  336.     fixGeometry(&Icongeom, icon_map_width, ht);
  337.     Icon = XCreateWindow(dpy, RootWindow(dpy, scr), Icongeom.x, Icongeom.y,
  338.                  icon_map_width, ht, 1, CopyFromParent, InputOutput,
  339.                  CopyFromParent, mask, &xswa);
  340. }
  341.  
  342. fixGeometry(g, w, h)
  343. register struct geom *        g;
  344. register int            w;
  345. register int            h;
  346. {
  347.     if (g->mask & XNegative)
  348.         g->x = DisplayWidth(dpy, scr) - w + g->x;
  349.     if (g->mask & YNegative)
  350.         g->y = DisplayHeight(dpy, scr) - h + g->y;
  351. }
  352.  
  353. makeGCs(w, p)
  354. register Window            w;
  355. register Pixmap            p;
  356. {
  357.     XGCValues        gcv;
  358.  
  359.     gcv.foreground = Black;
  360.     gcv.background = White;
  361.     GC_store = XCreateGC(dpy, w, GCForeground | GCBackground, &gcv);
  362.     gcv.function = GXinvert;
  363.     GC_invert = XCreateGC(dpy, p, GCForeground | GCBackground | GCFunction, &gcv);
  364.  
  365.     gcv.font = BigFont->fid;
  366.     GC_bigf = XCreateGC(dpy, w, GCForeground | GCBackground | GCFont, &gcv);
  367.     gcv.font = SmallFont->fid;
  368.     GC_smallf = XCreateGC(dpy, w, GCForeground | GCBackground | GCFont, &gcv);
  369. }
  370.  
  371. getColors()
  372. {
  373.     XColor            c;
  374.     XColor            e;
  375.     register Status        s;
  376.  
  377.     s = XAllocNamedColor(dpy, DefaultColormap(dpy, scr), "Black", &c, &e);
  378.     if (s != (Status)1) {
  379.         fprintf(stderr, "%s: warning: can't allocate color `Black'\n");
  380.         Black = BlackPixel(dpy, scr);
  381.     }
  382.     else
  383.         Black = c.pixel;
  384.     s = XAllocNamedColor(dpy, DefaultColormap(dpy, scr), "White", &c, &e);
  385.     if (s != (Status)1) {
  386.         fprintf(stderr, "%s: can't allocate color `White'\n");
  387.         White = WhitePixel(dpy, scr);
  388.     }
  389.     else
  390.         White = c.pixel;
  391. }
  392.  
  393. getFonts()
  394. {
  395.     BigFont = XLoadQueryFont(dpy, BIGFONT);
  396.     if (BigFont == (XFontStruct *)NULL) {
  397.         fprintf(stderr, "%s: can't open font `%s', using `%s'\n",
  398.             Name, BIGFONT, FAILFONT);
  399.         BigFont = XLoadQueryFont(dpy, FAILFONT);
  400.         if (BigFont == (XFontStruct *)NULL) {
  401.             fprintf(stderr, "%s: can't open font `%s', giving up\n",
  402.                 Name, FAILFONT);
  403.             exit(1);
  404.         }
  405.     }
  406.     SmallFont = XLoadQueryFont(dpy, SMALLFONT);
  407.     if (SmallFont == (XFontStruct *)NULL) {
  408.         fprintf(stderr, "%s: can't open font `%s', using `%s'\n",
  409.             Name, SMALLFONT, FAILFONT);
  410.         SmallFont = XLoadQueryFont(dpy, FAILFONT);
  411.         if (SmallFont == (XFontStruct *)NULL) {
  412.             fprintf(stderr, "%s: can't open font `%s', giving up\n",
  413.                 Name, FAILFONT);
  414.             exit(1);
  415.         }
  416.     }
  417. }
  418.  
  419. makePixmaps()
  420. {
  421.     Mappix = XCreatePixmapFromBitmapData(dpy, RootWindow(dpy, scr),
  422.                  large_map_bits, large_map_width,
  423.                  large_map_height, 0, 1, 1);
  424.  
  425.     Iconpix = XCreatePixmapFromBitmapData(dpy, RootWindow(dpy, scr),
  426.                  icon_map_bits, icon_map_width,
  427.                  icon_map_height, 0, 1, 1);
  428. }
  429.  
  430. makeClockContexts()
  431. {
  432.     register struct sunclock * s;
  433.  
  434.     s = makeClockContext(large_map_width, large_map_height, Clock, Mappix,
  435.                  GC_bigf, bigtprint, 70,
  436.                  large_map_height - BigFont->max_bounds.descent - 1);
  437.     Current = s;
  438.     s = makeClockContext(icon_map_width, icon_map_height, Icon, Iconpix,
  439.                  GC_smallf, smalltprint, 6,
  440.                  icon_map_height + SmallFont->max_bounds.ascent + 1);
  441.     Current->s_next = s;
  442.     s->s_flags |= S_ICON;
  443.     s->s_next = Current;
  444. }
  445.  
  446. struct sunclock *
  447. makeClockContext(wid, ht, win, pix, gc, fun, txx, txy)
  448. int                wid;
  449. int                ht;
  450. Window                win;
  451. Pixmap                pix;
  452. GC                gc;
  453. char *                (*fun)();
  454. int                txx;
  455. int                txy;
  456. {
  457.     register struct sunclock * s;
  458.  
  459.     s = (struct sunclock *)salloc(sizeof (struct sunclock));
  460.     s->s_width = wid;
  461.     s->s_height = ht;
  462.     s->s_window = win;
  463.     s->s_pixmap = pix;
  464.     s->s_flags = S_DIRTY;
  465.     s->s_noon = -1;
  466.     s->s_wtab = (short *)salloc((int)(ht * sizeof (short *)));
  467.     s->s_wtab1 = (short *)salloc((int)(ht * sizeof (short *)));
  468.     s->s_increm = 0L;
  469.     s->s_time = 0L;
  470.     s->s_gc    = gc;
  471.     s->s_tfunc = fun;
  472.     s->s_timeout = 0;
  473.     s->s_projtime = -1L;
  474.     s->s_text[0] = '\0';
  475.     s->s_textx = txx;
  476.     s->s_texty = txy;
  477.  
  478.     return (s);
  479. }    
  480.  
  481. /*
  482.  * Someone is sure to wonder why the event loop is coded this way, without
  483.  * using select().  The answer is that this was developed on a System V
  484.  * kernel, which has select() but the call has bugs; so, I was inspired
  485.  * to make it portable to systems without select().  The slight delay in
  486.  * expose event processing that results from using sleep(1) rather than
  487.  * alarm() is a fine payoff for not having to worry about interrupted
  488.  * system calls.
  489.  *
  490.  * I've got to use XCheckIfEvent with a degenerate predicate rather than
  491.  * XCheckMaskEvent with a mask of -1L because the latter won't collect all
  492.  * types of events, notably ClientMessage and Selection events.  Sigh.
  493.  */
  494.  
  495. eventLoop()
  496. {
  497.     XEvent            ev;
  498.  
  499.     for (;;) {
  500.         if (XCheckIfEvent(dpy, &ev, evpred, (char *)0))
  501.             switch (ev.type) {
  502.         
  503.             case Expose:
  504.                 if (ev.xexpose.count == 0)
  505.                     doExpose(ev.xexpose.window);
  506.                 break;
  507.             }
  508.         else {
  509.             sleep(1);
  510.             doTimeout();
  511.         }
  512.     }
  513. }
  514.  
  515. Bool
  516. evpred(d, e, a)
  517. register Display *        d;
  518. register XEvent *        e;
  519. register char *            a;
  520. {
  521.     return (True);
  522. }
  523.  
  524. /*
  525.  * Got an expose event for window w.  Do the right thing if it's not
  526.  * currently the one we're displaying.
  527.  */
  528.  
  529. doExpose(w)
  530. register Window            w;
  531. {
  532.     if (w != Current->s_window) {
  533.         Current = Current->s_next;
  534.         if (w != Current->s_window) {
  535.             fprintf(stderr,
  536.                 "%s: expose event for unknown window, id = 0x%08lx\n",
  537.                 w);
  538.             exit(1);
  539.         }
  540.         setTimeout(Current);
  541.     }
  542.     updimage(Current);
  543.     Current->s_flags |= S_DIRTY;
  544.     showImage(Current);
  545. }
  546.  
  547. doTimeout()
  548. {
  549.     if (QLength(dpy))
  550.         return;        /* ensure events processed first */
  551.     if (--Current->s_timeout <= 0) {
  552.         updimage(Current);
  553.         showImage(Current);
  554.         setTimeout(Current);
  555.     }
  556. }
  557.  
  558. setTimeout(s)
  559. register struct sunclock *    s;
  560. {
  561.     long            t;
  562.  
  563.     if (s->s_flags & S_ICON) {
  564.         time(&t);
  565.         s->s_timeout = 60 - localtime(&t)->tm_sec;
  566.     }
  567.     else
  568.         s->s_timeout = 1;
  569. }
  570.  
  571. showImage(s)
  572. register struct sunclock *    s;
  573. {
  574.     register char *        p;
  575.     struct tm        lt;
  576.     register struct tm *    gmtp;
  577.  
  578.     lt = *localtime(&s->s_time);
  579.     gmtp = gmtime(&s->s_time);
  580.     p = (*s->s_tfunc)(<, gmtp);
  581.  
  582.     if (s->s_flags & S_DIRTY) {
  583.         XCopyPlane(dpy, s->s_pixmap, s->s_window, GC_store, 0, 0,
  584.                s->s_width, s->s_height, 0, 0, 1);
  585.         if (s->s_flags & S_ICON)
  586.             XClearArea(dpy, s->s_window, 0, s->s_height + 1,
  587.                    0, 0, False);
  588.         s->s_flags &= ~S_DIRTY;
  589.     }
  590.     strcpy(s->s_text, p);
  591.     showText(s);
  592. }
  593.  
  594. showText(s)
  595. register struct sunclock *    s;
  596. {
  597.     XDrawImageString(dpy, s->s_window, s->s_gc, s->s_textx,
  598.              s->s_texty, s->s_text, strlen(s->s_text));
  599. }
  600.  
  601. /* --- */
  602. /*  UPDIMAGE  --  Update current displayed image.  */
  603.  
  604. updimage(s)
  605. register struct sunclock *    s;
  606. {
  607.     register int        i;
  608.     int            xl;
  609.     struct tm *        ct;
  610.     double            jt;
  611.     double            sunra;
  612.     double            sundec;
  613.     double            sunrv;
  614.     double            sunlong;
  615.     double            gt;
  616.     struct tm        lt;
  617.     short *            wtab_swap;
  618.  
  619.     /* If this is a full repaint of the window, force complete
  620.        recalculation. */
  621.  
  622.     if (s->s_noon < 0) {
  623.         s->s_projtime = 0;
  624.         for (i = 0; i < s->s_height; i++) {
  625.             s->s_wtab1[i] = -1;
  626.         }
  627.     }
  628.  
  629.     if (s->s_flags & S_FAKE) {
  630.         if (s->s_flags & S_ANIMATE)
  631.             s->s_time += s->s_increm;
  632.         if (s->s_time < 0)
  633.             s->s_time = 0;
  634.     } else
  635.         time(&s->s_time);
  636.     lt = *localtime(&s->s_time);
  637.  
  638.     ct = gmtime(&s->s_time);
  639.  
  640.     jt = jtime(ct);
  641.     sunpos(jt, False, &sunra, &sundec, &sunrv, &sunlong);
  642.     gt = gmst(jt);
  643.  
  644.     /* Projecting the illumination curve  for the current seasonal
  645.            instant is costly.  If we're running in real time, only  do
  646.        it every PROJINT seconds.  */
  647.  
  648.     if ((s->s_flags & S_FAKE)
  649.      || s->s_projtime < 0
  650.      || (s->s_time - s->s_projtime) > PROJINT) {
  651.         projillum(s->s_wtab, s->s_width, s->s_height, sundec);
  652.         wtab_swap = s->s_wtab;
  653.         s->s_wtab = s->s_wtab1;
  654.         s->s_wtab1 = wtab_swap;
  655.         s->s_projtime = s->s_time;
  656.     }
  657.  
  658.     sunlong = fixangle(180.0 + (sunra - (gt * 15)));
  659.     xl = sunlong * (s->s_width / 360.0);
  660.  
  661.     /* If the subsolar point has moved at least one pixel, update
  662.        the illuminated area on the screen.    */
  663.  
  664.     if ((s->s_flags & S_FAKE) || s->s_noon != xl) {
  665.         moveterm(s->s_wtab1, xl, s->s_wtab, s->s_noon, s->s_width,
  666.              s->s_height, s->s_pixmap);
  667.         s->s_noon = xl;
  668.         s->s_flags |= S_DIRTY;
  669.     }
  670. }
  671.  
  672. /*  PROJILLUM  --  Project illuminated area on the map.  */
  673.  
  674. projillum(wtab, xdots, ydots, dec)
  675. short *wtab;
  676. int xdots, ydots;
  677. double dec;
  678. {
  679.     int i, ftf = True, ilon, ilat, lilon, lilat, xt;
  680.     double m, x, y, z, th, lon, lat, s, c;
  681.  
  682.     /* Clear unoccupied cells in width table */
  683.  
  684.     for (i = 0; i < ydots; i++)
  685.         wtab[i] = -1;
  686.  
  687.     /* Build transformation for declination */
  688.  
  689.     s = sin(-dtr(dec));
  690.     c = cos(-dtr(dec));
  691.  
  692.     /* Increment over a semicircle of illumination */
  693.  
  694.     for (th = -(PI / 2); th <= PI / 2 + 0.001;
  695.         th += PI / TERMINC) {
  696.  
  697.         /* Transform the point through the declination rotation. */
  698.  
  699.         x = -s * sin(th);
  700.         y = cos(th);
  701.         z = c * sin(th);
  702.  
  703.         /* Transform the resulting co-ordinate through the
  704.            map projection to obtain screen co-ordinates. */
  705.  
  706.         lon = (y == 0 && x == 0) ? 0.0 : rtd(atan2(y, x));
  707.         lat = rtd(asin(z));
  708.  
  709.         ilat = ydots - (lat + 90) * (ydots / 180.0);
  710.         ilon = lon * (xdots / 360.0);
  711.  
  712.         if (ftf) {
  713.  
  714.             /* First time.  Just save start co-ordinate. */
  715.  
  716.             lilon = ilon;
  717.             lilat = ilat;
  718.             ftf = False;
  719.         } else {
  720.  
  721.             /* Trace out the line and set the width table. */
  722.  
  723.             if (lilat == ilat) {
  724.                 wtab[(ydots - 1) - ilat] = ilon == 0 ? 1 : ilon;
  725.             } else {
  726.                 m = ((double) (ilon - lilon)) / (ilat - lilat);
  727.                 for (i = lilat; i != ilat; i += sgn(ilat - lilat)) {
  728.                     xt = lilon + floor((m * (i - lilat)) + 0.5);
  729.                     wtab[(ydots - 1) - i] = xt == 0 ? 1 : xt;
  730.                 }
  731.             }
  732.             lilon = ilon;
  733.             lilat = ilat;
  734.         }
  735.     }
  736.  
  737.     /* Now tweak the widths to generate full illumination for
  738.        the correct pole. */
  739.  
  740.     if (dec < 0.0) {
  741.         ilat = ydots - 1;
  742.         lilat = -1;
  743.     } else {
  744.         ilat = 0;
  745.         lilat = 1;
  746.     }
  747.  
  748.     for (i = ilat; i != ydots / 2; i += lilat) {
  749.         if (wtab[i] != -1) {
  750.             while (True) {
  751.                 wtab[i] = xdots / 2;
  752.                 if (i == ilat)
  753.                     break;
  754.                 i -= lilat;
  755.             }
  756.             break;
  757.         }
  758.     }
  759. }
  760.  
  761. /*  XSPAN  --  Complement a span of pixels.  Called with line in which
  762.            pixels are contained, leftmost pixel in the  line,  and
  763.            the   number   of   pixels   to     complement.   Handles
  764.            wrap-around at the right edge of the screen.  */
  765.  
  766. xspan(pline, leftp, npix, xdots, p)
  767. register int            pline;
  768. register int            leftp;
  769. register int            npix;
  770. register int            xdots;
  771. register Pixmap            p;
  772. {
  773.     leftp = leftp % xdots;
  774.  
  775.     if (leftp + npix > xdots) {
  776.         XDrawLine(dpy, p, GC_invert, leftp, pline, xdots - 1, pline);
  777.         XDrawLine(dpy, p, GC_invert, 0, pline,
  778.               (leftp + npix) - (xdots + 1), pline);
  779.     }
  780.     else
  781.         XDrawLine(dpy, p, GC_invert, leftp, pline,
  782.               leftp + (npix - 1), pline);
  783. }
  784.  
  785. /*  MOVETERM  --  Update illuminated portion of the globe.  */
  786.  
  787. moveterm(wtab, noon, otab, onoon, xdots, ydots, pixmap)
  788. short *wtab, *otab;
  789. int noon, onoon, xdots, ydots;
  790. Pixmap pixmap;
  791. {
  792.     int i, ol, oh, nl, nh;
  793.  
  794.     for (i = 0; i < ydots; i++) {
  795.  
  796.         /* If line is off in new width table but is set in
  797.            the old table, clear it. */
  798.  
  799.         if (wtab[i] < 0) {
  800.             if (otab[i] >= 0) {
  801.                 xspan(i, ((onoon - otab[i]) + xdots) % xdots,
  802.                     otab[i] * 2, xdots, pixmap);
  803.             }
  804.         } else {
  805.  
  806.             /* Line is on in new width table.  If it was off in
  807.                the old width table, just draw it. */
  808.  
  809.             if (otab[i] < 0) {
  810.                 xspan(i, ((noon - wtab[i]) + xdots) % xdots,
  811.                     wtab[i] * 2, xdots, pixmap);
  812.             } else {
  813.  
  814.                 /* If both the old and new spans were the entire
  815.                    screen, they're equivalent. */
  816.  
  817.                 if (otab[i] == wtab[i] && wtab[i] == (xdots / 2))
  818.                     continue;
  819.  
  820.                 /* The line was on in both the old and new width
  821.                    tables.  We must adjust the difference in the
  822.                    span.  */
  823.  
  824.                 ol =  ((onoon - otab[i]) + xdots) % xdots;
  825.                 oh = (ol + otab[i] * 2) - 1;
  826.                 nl =  ((noon - wtab[i]) + xdots) % xdots;
  827.                 nh = (nl + wtab[i] * 2) - 1;
  828.  
  829.                 /* If spans are disjoint, erase old span and set
  830.                    new span. */
  831.  
  832.                 if (oh < nl || nh < ol) {
  833.                     xspan(i, ol, (oh - ol) + 1, xdots, pixmap);
  834.                     xspan(i, nl, (nh - nl) + 1, xdots, pixmap);
  835.                 } else {
  836.                     /* Clear portion(s) of old span that extend
  837.                        beyond end of new span. */
  838.                     if (ol < nl) {
  839.                         xspan(i, ol, nl - ol, xdots, pixmap);
  840.                         ol = nl;
  841.                     }
  842.                     if (oh > nh) {
  843.                         xspan(i, nh + 1, oh - nh, xdots, pixmap);
  844.                         oh = nh;
  845.                     }
  846.                     /* Extend existing (possibly trimmed) span to
  847.                        correct new length. */
  848.                     if (nl < ol) {
  849.                         xspan(i, nl, ol - nl, xdots, pixmap);
  850.                     }
  851.                     if (nh > oh) {
  852.                         xspan(i, oh + 1, nh - oh, xdots, pixmap);
  853.                     }
  854.                 }
  855.             }
  856.         }
  857.         otab[i] = wtab[i];
  858.     }
  859. }
  860.  
  861. char *
  862. salloc(nbytes)
  863. register int            nbytes;
  864. {
  865.     register char *        p;
  866.  
  867.     p = malloc((unsigned)nbytes);
  868.     if (p == (char *)NULL) {
  869.         fprintf(stderr, "%s: out of memory\n");
  870.         exit(1);
  871.     }
  872.     return (p);
  873. }
  874.  
  875. char *
  876. bigtprint(ltp, gmtp)
  877. register struct tm *        ltp;
  878. register struct tm *        gmtp;
  879. {
  880.     static char        s[80];
  881.  
  882.     sprintf(s,
  883.         "%02d:%02d:%02d %s %s %02d %s %02d     %02d:%02d:%02d UTC %s %02d %s %02d",
  884.         ltp->tm_hour, ltp->tm_min,
  885.         ltp->tm_sec,
  886. #ifdef    NEW_CTIME
  887.         ltp->tm_zone,
  888. #else
  889.          tzname[ltp->tm_isdst],
  890. #endif
  891.         Wdayname[ltp->tm_wday], ltp->tm_mday,
  892.         Monname[ltp->tm_mon], ltp->tm_year % 100,
  893.         gmtp->tm_hour, gmtp->tm_min,
  894.         gmtp->tm_sec, Wdayname[gmtp->tm_wday], gmtp->tm_mday,
  895.         Monname[gmtp->tm_mon], gmtp->tm_year % 100);
  896.  
  897.     return (s);
  898. }
  899.  
  900. char *
  901. smalltprint(ltp, gmtp)
  902. register struct tm *        ltp;
  903. register struct tm *        gmtp;
  904. {
  905.     static char        s[80];
  906.  
  907.     sprintf(s, "%02d:%02d %s %02d %s %02d", ltp->tm_hour, ltp->tm_min,
  908.         Wdayname[ltp->tm_wday], ltp->tm_mday, Monname[ltp->tm_mon],
  909.         ltp->tm_year % 100);
  910.  
  911.     return (s);
  912. }
  913.